In [1]:
## For data
import pandas as pd
import numpy as np
## For plotting
import matplotlib.pyplot as plt
## For Arima
import pmdarima
import statsmodels.tsa.api as smt
## For Lstm
#from tensorflow.keras import models, layers, preprocessing as kprocessing
## For Prophet
from fbprophet import Prophet
import seaborn as sns
# Use seaborn style defaults and set the default figure size
sns.set(rc={'figure.figsize':(11, 4)})
In [2]:
dtf = pd.read_csv('C:\\Users\\garvi\\OneDrive\\Documents\\Nifty 50 Historical Data.csv',thousands=',')
dtf.head()
Out[2]:
In [3]:
dtf.describe()
Out[3]:
In [4]:
dtf["Date"] = pd.to_datetime(dtf["Date"],infer_datetime_format=True)
dtf =dtf.iloc[::-1]
In [5]:
# Rename the features: These names are NEEDED for the model fitting
dtf = dtf[["Date","Price"]]
dtf = dtf.rename(columns = {"Date":"ds","Price":"y"}) #renaming the columns of the dataset
In [7]:
dtf.head()
Out[7]:
In [8]:
m = Prophet(daily_seasonality = True) # the Prophet class (model)
m.fit(dtf) # fit the model using all data
Out[8]:
In [9]:
future = m.make_future_dataframe(periods=365) #we need to specify the number of days in future
prediction = m.predict(future)
m.plot(prediction)
plt.title("Prediction of the NSE50 using the Prophet")
plt.xlabel("Date")
plt.ylabel("Closing Price")
plt.show()
In [10]:
m.plot_components(prediction)
plt.show()
In [11]:
# selecting Date till 2018 for training and 2018-2019 as testing
train = (dtf['ds'] <'2018-12-31')
train = dtf.loc[train]
test = (dtf['ds'] >'2018-12-31') & (dtf['ds']<'2019-12-31')
test = dtf.loc[test]
In [12]:
train.head()
Out[12]:
In [13]:
train.tail()
Out[13]:
In [14]:
test.head()
Out[14]:
In [15]:
test.tail()
Out[15]:
In [16]:
#Fit model using train data
model = Prophet(daily_seasonality = True) # the Prophet class (model)
model.fit(train) # fit the model using all data
Out[16]:
In [69]:
future = model.make_future_dataframe(periods=365) #we need to specify the number of days in future
prediction = model.predict(future)
model.plot(prediction)
plt.title("Prediction of the NSE50 using the Prophet")
plt.xlabel("Date")
plt.ylabel("Close Stock Price")
plt.plot(test['ds'],test['y'],color='red')
#plt.savefig('myfig.png')
fig = plt.gcf()
fig.set_size_inches(18.5, 10.5)
fig.savefig('test2png.png', dpi=300)
plt.show()
In [18]:
model.plot_components(prediction)
plt.show()
In [19]:
from fbprophet.plot import plot_plotly
import plotly.offline as py
py.init_notebook_mode()
fig = plot_plotly(model, prediction)
py.iplot(fig)
In [29]:
prediction
Out[29]:
In [82]:
plt.plot(prediction['ds'], prediction[['yhat_lower','yhat_upper','yhat']],linewidth=1.0)
plt.ylabel('Nifty50 value')
plt.plot(train['ds'],train['y'],color='black',linewidth=1.0)
plt.plot(test['ds'],test['y'],linewidth=1.0)
fig = plt.gcf()
fig.set_size_inches(18.5, 10.5)
plt.plot()
plt.show()
In [86]:
def fit_prophet(train, test, lst_exog=None, model=None,
freq="D", figsize=(15,10)):
## train
model2 = Prophet(daily_seasonality = True) # the Prophet class (model)
model2.fit(train)
## test
dtf_prophet = model.make_future_dataframe(periods=len(test),
freq=freq, include_history=True)
dtf_prophet = model.predict(dtf_prophet)
train = train.merge(dtf_prophet[["ds","yhat"]],
how="left").rename(columns={'yhat':'model',
'y':'ts'}).set_index("ds")
test = test.merge(dtf_prophet[["ds","yhat"]],
how="left").rename(columns={'yhat':'forecast',
'y':'ts'}).set_index("ds")
## evaluate
dtf = train.append(test)
dtf = utils_evaluate_forecast(dtf, figsize=figsize,
title="Prophet")
return dtf, model
In [88]:
def utils_evaluate_forecast(dtf, title, plot=True, figsize=(20,13)):
try:
## residuals
dtf["residuals"] = dtf["ts"] - dtf["model"]
dtf["error"] = dtf["ts"] - dtf["forecast"]
dtf["error_pct"] = dtf["error"] / dtf["ts"]
## kpi
residuals_mean = dtf["residuals"].mean()
residuals_std = dtf["residuals"].std()
error_mean = dtf["error"].mean()
error_std = dtf["error"].std()
mae = dtf["error"].apply(lambda x: np.abs(x)).mean()
mape = dtf["error_pct"].apply(lambda x: np.abs(x)).mean()
mse = dtf["error"].apply(lambda x: x**2).mean()
rmse = np.sqrt(mse) #root mean squared error
## intervals
dtf["conf_int_low"] = dtf["forecast"] - 1.96*residuals_std
dtf["conf_int_up"] = dtf["forecast"] + 1.96*residuals_std
dtf["pred_int_low"] = dtf["forecast"] - 1.96*error_std
dtf["pred_int_up"] = dtf["forecast"] + 1.96*error_std
## plot
if plot==True:
fig = plt.figure(figsize=figsize)
fig.suptitle(title, fontsize=20)
ax1 = fig.add_subplot(2,2, 1)
ax2 = fig.add_subplot(2,2, 2, sharey=ax1)
ax3 = fig.add_subplot(2,2, 3)
ax4 = fig.add_subplot(2,2, 4)
### training
dtf[pd.notnull(dtf["model"])][["ts","model"]].plot(color=["black","green"], title="Model", grid=True, ax=ax1)
ax1.set(xlabel=None)
### test
dtf[pd.isnull(dtf["model"])][["ts","forecast"]].plot(color=["black","red"], title="Forecast", grid=True, ax=ax2)
ax2.fill_between(x=dtf.index, y1=dtf['pred_int_low'], y2=dtf['pred_int_up'], color='b', alpha=0.2)
ax2.fill_between(x=dtf.index, y1=dtf['conf_int_low'], y2=dtf['conf_int_up'], color='b', alpha=0.3)
ax2.set(xlabel=None)
### residuals
dtf[["residuals","error"]].plot(ax=ax3, color=["green","red"], title="Residuals", grid=True)
ax3.set(xlabel=None)
### residuals distribution
dtf[["residuals","error"]].plot(ax=ax4, color=["green","red"], kind='kde', title="Residuals Distribution", grid=True)
ax4.set(ylabel=None)
plt.show()
print("Training --> Residuals mean:", np.round(residuals_mean), " | std:", np.round(residuals_std))
print("Test --> Error mean:", np.round(error_mean), " | std:", np.round(error_std),
" | mae:",np.round(mae), " | mape:",np.round(mape*100), "% | mse:",np.round(mse), " | rmse:",np.round(rmse))
return dtf[["ts","model","residuals","conf_int_low","conf_int_up",
"forecast","error","pred_int_low","pred_int_up"]]
except Exception as e:
print("--- got error ---")
print(e)
In [89]:
dtf, model = fit_prophet(train, test, model=model, freq="D")
In [ ]: